<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Lucene.Net.Contrib.Highlighter</name>
    </assembly>
    <members>
        <member name="T:Lucene.Net.Highlight.WeightedTerm">
            <summary>Lightweight class to hold term and a weight value used for scoring this term </summary>
            <author>  Mark Harwood
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.WeightedTerm.GetTerm">
            <returns> the term value (stemmed)
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.WeightedTerm.GetWeight">
            <returns> the weight associated with this term
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.WeightedTerm.SetTerm(System.String)">
            <param name="term">the term value (stemmed)
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.WeightedTerm.SetWeight(System.Single)">
            <param name="weight">the weight associated with this term
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.Fragmenter">
            <summary> Implements the policy for breaking text into multiple fragments for consideration
            by the <see cref="T:Lucene.Net.Highlight.Highlighter"/> class. A sophisticated implementation may do this on the basis
            of detecting end of sentences in the text. 
            </summary>
            <author>  mark@searcharea.co.uk
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.Fragmenter.Start(System.String)">
            <summary> Initializes the Fragmenter</summary>
            <param name="originalText">
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.Fragmenter.IsNewFragment(Lucene.Net.Analysis.Token)">
            <summary> Test to see if this token from the stream should be held in a new TextFragment</summary>
            <param name="nextToken">
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.TokenGroup">
            <summary> One, or several overlapping tokens, along with the score(s) and the
            scope of the original text
            </summary>
            <author>  MAHarwood
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenGroup.GetToken(System.Int32)">
            <summary> </summary>
            <param name="index">a value between 0 and numTokens -1
            </param>
            <returns> the "n"th token
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenGroup.GetScore(System.Int32)">
            <summary> </summary>
            <param name="index">a value between 0 and numTokens -1
            </param>
            <returns> the "n"th score
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenGroup.GetEndOffset">
            <returns> the end position in the original text
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenGroup.GetNumTokens">
            <returns> the number of tokens in this group
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenGroup.GetStartOffset">
            <returns> the start position in the original text
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenGroup.GetTotalScore">
            <returns> all tokens' scores summed up
            </returns>
        </member>
        <member name="T:Lucene.Net.Highlight.QueryScorer">
            <summary> <see cref="T:Lucene.Net.Highlight.Scorer"/> implementation which scores text fragments by the number of unique query terms found.
            This class uses the <see cref="T:Lucene.Net.Highlight.QueryTermExtractor"/> class to process determine the query terms and 
            their boosts to be used. 
            </summary>
            <author>  mark@searcharea.co.uk
            </author>
        </member>
        <member name="T:Lucene.Net.Highlight.Scorer">
            <summary> Adds to the score for a fragment based on its tokens</summary>
            <author>  mark@searcharea.co.uk
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.Scorer.StartFragment(Lucene.Net.Highlight.TextFragment)">
            <summary> called when a new fragment is started for consideration</summary>
            <param name="newFragment"></param>
        </member>
        <member name="M:Lucene.Net.Highlight.Scorer.GetTokenScore(Lucene.Net.Analysis.Token)">
            <summary> Called for each token in the current fragment</summary>
            <param name="token">The token to be scored
            </param>
            <returns> a score which is passed to the Highlighter class to influence the mark-up of the text
            (this return value is NOT used to score the fragment)
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Scorer.GetFragmentScore">
            <summary> Called when the highlighter has no more tokens for the current fragment - the scorer returns
            the weighting it has derived for the most recent fragment, typically based on the tokens
            passed to getTokenScore(). 
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryScorer.#ctor(Lucene.Net.Search.Query)">
            <summary> </summary>
            <param name="query">a Lucene query (ideally rewritten using query.rewrite 
            before being passed to this class and the searcher)
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryScorer.#ctor(Lucene.Net.Search.Query,System.String)">
            <summary> </summary>
            <param name="query">a Lucene query (ideally rewritten using query.rewrite 
            before being passed to this class and the searcher)
            </param>
            <param name="fieldName">the Field name which is used to match Query terms
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryScorer.#ctor(Lucene.Net.Search.Query,Lucene.Net.Index.IndexReader,System.String)">
            <summary> </summary>
            <param name="query">a Lucene query (ideally rewritten using query.rewrite 
            before being passed to this class and the searcher)
            </param>
            <param name="reader">used to compute IDF which can be used to a) score selected fragments better 
            b) use graded highlights eg set font color intensity
            </param>
            <param name="fieldName">the field on which Inverse Document Frequency (IDF) calculations are based
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryScorer.GetMaxTermWeight">
            <summary> </summary>
            <returns> The highest weighted term (useful for passing to GradientFormatter to set
            top end of coloring scale.  
            </returns>
        </member>
        <member name="T:Lucene.Net.Highlight.DefaultEncoder">
            <summary> Simple <see cref="T:Lucene.Net.Highlight.Encoder"/> implementation that does not modify the output</summary>
            <author>  Nicko Cadell
            
            </author>
        </member>
        <member name="T:Lucene.Net.Highlight.Encoder">
            <summary> Encodes original text. The Encoder works with the Formatter to generate the output.
            
            </summary>
            <author>  Nicko Cadell
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.Encoder.EncodeText(System.String)">
            <param name="originalText">The section of text being output
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.TextFragment">
            <summary> Low-level class used to record information about a section of a document 
            with a score.
            </summary>
            <author>  MAHarwood
            
            
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.TextFragment.Merge(Lucene.Net.Highlight.TextFragment)">
            <param name="frag2">Fragment to be merged into this one
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.TextFragment.Follows(Lucene.Net.Highlight.TextFragment)">
            <param name="fragment">
            </param>
            <returns> true if this fragment follows the one passed
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.TextFragment.GetFragNum">
            <returns> the fragment sequence number
            </returns>
        </member>
        <member name="T:Lucene.Net.Highlight.SimpleFragmenter">
            <summary> <see cref="T:Lucene.Net.Highlight.Fragmenter"/> implementation which breaks text up into same-size 
            fragments with no concerns over spotting sentence boundaries.
            </summary>
            <author>  mark@searcharea.co.uk
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.SimpleFragmenter.#ctor(System.Int32)">
            <summary> </summary>
            <param name="fragmentSize">size in bytes of each fragment
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.SimpleFragmenter.GetFragmentSize">
            <returns> size in bytes of each fragment
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.SimpleFragmenter.SetFragmentSize(System.Int32)">
            <param name="size">size in bytes of each fragment
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.Formatter">
            <summary> Processes terms found in the original text, typically by applying some form 
            of mark-up to highlight terms in HTML search results pages.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Highlight.Formatter.HighlightTerm(System.String,Lucene.Net.Highlight.TokenGroup)">
            <param name="originalText">The section of text being considered for markup
            </param>
            <param name="tokenGroup">contains one or several overlapping Tokens along with
            their scores and positions.
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.QueryTermExtractor">
            <summary> Utility class used to extract the terms used in a query, plus any weights.
            This class will not find terms for MultiTermQuery, RangeQuery and PrefixQuery classes
            so the caller must pass a rewritten query (see Query.rewrite) to obtain a list of 
            expanded terms. 
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryTermExtractor.GetTerms(Lucene.Net.Search.Query)">
            <summary> Extracts all terms texts of a given Query into an array of WeightedTerms
            
            </summary>
            <param name="query">     Query to extract term texts from
            </param>
            <returns> an array of the terms used in a query, plus their weights.
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryTermExtractor.GetIdfWeightedTerms(Lucene.Net.Search.Query,Lucene.Net.Index.IndexReader,System.String)">
            <summary> Extracts all terms texts of a given Query into an array of WeightedTerms
            
            </summary>
            <param name="query">     Query to extract term texts from
            </param>
            <param name="reader">used to compute IDF which can be used to a) score selected fragments better 
            b) use graded highlights eg chaning intensity of font color
            </param>
            <param name="fieldName">the field on which Inverse Document Frequency (IDF) calculations are based
            </param>
            <returns> an array of the terms used in a query, plus their weights.
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryTermExtractor.GetTerms(Lucene.Net.Search.Query,System.Boolean,System.String)">
            <summary> Extracts all terms texts of a given Query into an array of WeightedTerms
            
            </summary>
            <param name="query">     Query to extract term texts from
            </param>
            <param name="prohibited"><c>true</c> to extract "prohibited" terms, too
            </param>
            <param name="fieldName"> The fieldName used to filter query terms
            </param>
            <returns> an array of the terms used in a query, plus their weights.
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryTermExtractor.GetTerms(Lucene.Net.Search.Query,System.Boolean)">
            <summary> Extracts all terms texts of a given Query into an array of WeightedTerms
            
            </summary>
            <param name="query">     Query to extract term texts from
            </param>
            <param name="prohibited"><c>true</c> to extract "prohibited" terms, too
            </param>
            <returns> an array of the terms used in a query, plus their weights.
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.QueryTermExtractor.GetTermsFromBooleanQuery(Lucene.Net.Search.BooleanQuery,System.Collections.Hashtable,System.Boolean,System.String)">
            <summary> extractTerms is currently the only query-independent means of introspecting queries but it only reveals
            a list of terms for that query - not the boosts each individual term in that query may or may not have.
            "Container" queries such as BooleanQuery should be unwrapped to get at the boost info held
            in each child element. 
            Some discussion around this topic here:
            http://www.gossamer-threads.com/lists/lucene/java-dev/34208?search_string=introspection;#34208
            Unfortunately there seemed to be limited interest in requiring all Query objects to implement
            something common which would allow access to child queries so what follows here are query-specific
            implementations for accessing embedded query elements. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Highlight.NullFragmenter">
            <summary> <see cref="T:Lucene.Net.Highlight.Fragmenter"/> implementation which does not fragment the text.
            This is useful for highlighting the entire content of a document or field.
            </summary>
        </member>
        <member name="T:Lucene.Net.Highlight.SpanGradientFormatter">
            <summary> Formats text with different color intensity depending on the score of the
            term using the span tag.  GradientFormatter uses a bgcolor argument to the font tag which
            doesn't work in Mozilla, thus this class.
            
            </summary>
            <seealso cref="T:Lucene.Net.Highlight.GradientFormatter">
            </seealso>
            <author>  David Spencer dave@searchmorph.com
            </author>
        </member>
        <member name="T:Lucene.Net.Highlight.GradientFormatter">
            <summary> Formats text with different color intensity depending on the score of the
            term.
            
            </summary>
            <author>  maharwood
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.GradientFormatter.#ctor(System.Single,System.String,System.String,System.String,System.String)">
            <summary> Sets the color range for the IDF scores
            
            </summary>
            <param name="maxScore">
            The score (and above) displayed as maxColor (See QueryScorer.getMaxWeight 
            which can be used to callibrate scoring scale)
            </param>
            <param name="minForegroundColor">
            The hex color used for representing IDF scores of zero eg
            #FFFFFF (white) or null if no foreground color required
            </param>
            <param name="maxForegroundColor">
            The largest hex color used for representing IDF scores eg
            #000000 (black) or null if no foreground color required
            </param>
            <param name="minBackgroundColor">
            The hex color used for representing IDF scores of zero eg
            #FFFFFF (white) or null if no background color required
            </param>
            <param name="maxBackgroundColor">
            The largest hex color used for representing IDF scores eg
            #000000 (black) or null if no background color required
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.GradientFormatter.HexToInt(System.String)">
            <summary> Converts a hex string into an int. Integer.parseInt(hex, 16) assumes the
            input is nonnegative unless there is a preceding minus sign. This method
            reads the input as twos complement instead, so if the input is 8 bytes
            long, it will correctly restore a negative int produced by
            Integer.toHexString() but not neccesarily one produced by
            Integer.toString(x,16) since that method will produce a string like '-FF'
            for negative integer values.
            
            </summary>
            <param name="hex">
            A string in capital or lower case hex, of no more then 16
            characters.
            </param>
            <exception cref="T:System.FormatException">if the string is more than 16 characters long, or if any
            character is not in the set [0-9a-fA-f]</exception>
        </member>
        <member name="T:Lucene.Net.Highlight.SimpleHTMLFormatter">
            <summary> Simple <see cref="T:Lucene.Net.Highlight.Formatter"/> implementation to highlight terms with a pre and post tag</summary>
            <author>  MAHarwood
            
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.SimpleHTMLFormatter.#ctor">
            <summary> Default constructor uses HTML: &lt;B&gt; tags to markup terms
            
            
            </summary>
        </member>
        <member name="T:Lucene.Net.Highlight.TokenSources">
            <summary> Hides implementation issues associated with obtaining a TokenStream for use with
            the higlighter - can obtain from TermFreqVectors with offsets and (optionally) positions or
            from Analyzer class reparsing the stored content. 
            </summary>
            <author>  maharwood
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenSources.GetAnyTokenStream(Lucene.Net.Index.IndexReader,System.Int32,System.String,Lucene.Net.Analysis.Analyzer)">
            <summary> A convenience method that tries a number of approaches to getting a token stream.
            The cost of finding there are no termVectors in the index is minimal (1000 invocations still 
            registers 0 ms). So this "lazy" (flexible?) approach to coding is probably acceptable
            </summary>
            <param name="reader"> </param>
            <param name="docId"> </param>
            <param name="field"> </param>
            <param name="analyzer"> </param>
            <returns> null if field not stored correctly </returns>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Highlight.TokenSources.GetTokenStream(Lucene.Net.Index.TermPositionVector,System.Boolean)">
            <summary> Low level api.
            Returns a token stream or null if no offset info available in index.
            This can be used to feed the highlighter with a pre-parsed token stream 
            
            In my tests the speeds to recreate 1000 token streams using this method are:
            - with TermVector offset only data stored - 420  milliseconds 
            - with TermVector offset AND position data stored - 271 milliseconds
            (nb timings for TermVector with position data are based on a tokenizer with contiguous
            positions - no overlaps or gaps)
            The cost of not using TermPositionVector to store
            pre-parsed content and using an analyzer to re-parse the original content: 
            - reanalyzing the original content - 980 milliseconds
            
            The re-analyze timings will typically vary depending on -
            1) The complexity of the analyzer code (timings above were using a 
            stemmer/lowercaser/stopword combo)
            2) The  number of other fields (Lucene reads ALL fields off the disk 
            when accessing just one document field - can cost dear!)
            3) Use of compression on field storage - could be faster cos of compression (less disk IO)
            or slower (more CPU burn) depending on the content.
            
            </summary>
            <param name="tpv"></param>
            <param name="tokenPositionsGuaranteedContiguous">true if the token position numbers have no overlaps or gaps. If looking
            to eek out the last drops of performance, set to true. If in doubt, set to false.
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.Highlighter">
            <summary> Class used to markup highlighted terms found in the best sections of a 
            text, using configurable <see cref="T:Lucene.Net.Highlight.Fragmenter"/>, <see cref="T:Lucene.Net.Highlight.Scorer"/>, <see cref="T:Lucene.Net.Highlight.Formatter"/>, 
            <see cref="T:Lucene.Net.Highlight.Encoder"/> and tokenizers.
            </summary>
            <author>  mark@searcharea.co.uk
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestFragment(Lucene.Net.Analysis.Analyzer,System.String,System.String)">
            <summary> Highlights chosen terms in a text, extracting the most relevant section.
            This is a convenience method that calls
            <see cref="M:Lucene.Net.Highlight.Highlighter.GetBestFragment(Lucene.Net.Analysis.TokenStream,System.String)"/>
            
            </summary>
            <param name="analyzer">  the analyzer that will be used to split <c>text</c>
            into chunks  
            </param>
            <param name="text">text to highlight terms in
            </param>
            <param name="fieldName">Name of field used to influence analyzer's tokenization policy 
            
            </param>
            <returns> highlighted text fragment or null if no terms found
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestFragment(Lucene.Net.Analysis.TokenStream,System.String)">
            <summary> Highlights chosen terms in a text, extracting the most relevant section.
            The document text is analysed in chunks to record hit statistics
            across the document. After accumulating stats, the fragment with the highest score
            is returned
            
            </summary>
            <param name="tokenStream">  a stream of tokens identified in the text parameter, including offset information. 
            This is typically produced by an analyzer re-parsing a document's 
            text. Some work may be done on retrieving TokenStreams more efficently 
            by adding support for storing original text position data in the Lucene
            index but this support is not currently available (as of Lucene 1.4 rc2).  
            </param>
            <param name="text">text to highlight terms in
            
            </param>
            <returns> highlighted text fragment or null if no terms found
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestFragments(Lucene.Net.Analysis.Analyzer,System.String,System.Int32)">
            <summary> Highlights chosen terms in a text, extracting the most relevant sections.
            This is a convenience method that calls
            <see cref="M:Lucene.Net.Highlight.Highlighter.GetBestFragments(Lucene.Net.Analysis.TokenStream,System.String,System.Int32)"/>
            
            </summary>
            <param name="analyzer">  the analyzer that will be used to split <c>text</c>
            into chunks  
            </param>
            <param name="text">       	text to highlight terms in
            </param>
            <param name="maxNumFragments"> the maximum number of fragments.
            </param>
            <deprecated> This method incorrectly hardcodes the choice of fieldname. Use the
            method of the same name that takes a fieldname.
            </deprecated>
            <returns> highlighted text fragments (between 0 and maxNumFragments number of fragments)
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestFragments(Lucene.Net.Analysis.Analyzer,System.String,System.String,System.Int32)">
            <summary> Highlights chosen terms in a text, extracting the most relevant sections.
            This is a convenience method that calls
            <see cref="M:Lucene.Net.Highlight.Highlighter.GetBestFragments(Lucene.Net.Analysis.TokenStream,System.String,System.Int32)"/>
            
            </summary>
            <param name="analyzer">  the analyzer that will be used to split <c>text</c>
            into chunks  
            </param>
            <param name="fieldName">    the name of the field being highlighted (used by analyzer)
            </param>
            <param name="text">       	text to highlight terms in
            </param>
            <param name="maxNumFragments"> the maximum number of fragments.
            
            </param>
            <returns> highlighted text fragments (between 0 and maxNumFragments number of fragments)
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestFragments(Lucene.Net.Analysis.TokenStream,System.String,System.Int32)">
            <summary> Highlights chosen terms in a text, extracting the most relevant sections.
            The document text is analysed in chunks to record hit statistics
            across the document. After accumulating stats, the fragments with the highest scores
            are returned as an array of strings in order of score (contiguous fragments are merged into 
            one in their original order to improve readability)
            
            </summary>
            <param name="text">       	text to highlight terms in
            </param>
            <param name="maxNumFragments"> the maximum number of fragments.
            
            </param>
            <returns> highlighted text fragments (between 0 and maxNumFragments number of fragments)
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestTextFragments(Lucene.Net.Analysis.TokenStream,System.String,System.Boolean,System.Int32)">
            <summary> Low level api to get the most relevant (formatted) sections of the document.
            This method has been made public to allow visibility of score information held in TextFragment objects.
            Thanks to Jason Calabrese for help in redefining the interface.  
            </summary>
            <param name="tokenStream">
            </param>
            <param name="text">
            </param>
            <param name="maxNumFragments">
            </param>
            <param name="mergeContiguousFragments">
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.MergeContiguousFragments(Lucene.Net.Highlight.TextFragment[])">
            <summary>Improves readability of a score-sorted list of TextFragments by merging any fragments 
            that were contiguous in the original text into one larger fragment with the correct order.
            This will leave a "null" in the array entry for the lesser scored fragment. 
            
            </summary>
            <param name="frag">An array of document fragments in descending score
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetBestFragments(Lucene.Net.Analysis.TokenStream,System.String,System.Int32,System.String)">
            <summary> Highlights terms in the  text , extracting the most relevant sections
            and concatenating the chosen fragments with a separator (typically "...").
            The document text is analysed in chunks to record hit statistics
            across the document. After accumulating stats, the fragments with the highest scores
            are returned in order as "separator" delimited strings.
            
            </summary>
            <param name="text">       text to highlight terms in
            </param>
            <param name="maxNumFragments"> the maximum number of fragments.
            </param>
            <param name="separator"> the separator used to intersperse the document fragments (typically "...")
            
            </param>
            <returns> highlighted text
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetMaxDocBytesToAnalyze">
            <returns> the maximum number of bytes to be tokenized per doc 
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.SetMaxDocBytesToAnalyze(System.Int32)">
            <param name="byteCount">the maximum number of bytes to be tokenized per doc
            (This can improve performance with large documents)
            </param>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.SetTextFragmenter(Lucene.Net.Highlight.Fragmenter)">
            <param name="fragmenter"> </param>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.GetFragmentScorer">
            <returns> Object used to score each text fragment 
            </returns>
        </member>
        <member name="M:Lucene.Net.Highlight.Highlighter.SetFragmentScorer(Lucene.Net.Highlight.Scorer)">
            <param name="scorer">
            </param>
        </member>
        <member name="T:Lucene.Net.Highlight.SimpleHTMLEncoder">
            <summary> Simple <see cref="T:Lucene.Net.Highlight.Encoder"/> implementation to escape text for HTML output</summary>
            <author>  Nicko Cadell
            
            </author>
        </member>
        <member name="M:Lucene.Net.Highlight.SimpleHTMLEncoder.HtmlEncode(System.String)">
            <summary> Encode string into HTML</summary>
        </member>
    </members>
</doc>
